package main

import (
	_ "baseLearning/base1/pkg" //引入某个包，但不直接使用包里的函数，而是调用该包里面的init函数
	"fmt"
	"sync"
)

/*
channel，是一种带有类型的管道引用类型

使用前需要make(Type, (缓冲容量))

不带缓冲区的管道必须结合协程使用

可以查看长度len和容量ca

*
*/
func main() {
	fmt.Println("xxx")
	// 声明一个string信道，容量为2
	var ch chan string = make(chan string, 2)

	ch <- "枫枫" // 写入数据到信道中
	ch <- "知道"

	s := <-ch // 从信道读取数据
	fmt.Println(s)
	ss, ok := <-ch
	fmt.Println(ss, ok)

	close(ch)

	var c1 chan int = make(chan int, 2) // 2表示缓冲区大小
	go pushNum(c1)

	// for value := range c1 {
	// 	fmt.Println(value)
	// }

	//mutiRoutine()
	//readWrite()

	selectCase()

}

func pushNum(c chan int) {
	for i := 0; i < 100; i++ {
		c <- i
	}
	close(c) // 写完必须要关闭，不然会死锁
}

// 多个协程函数，close就不能写在协程函数里了
var ch chan int = make(chan int, 10)
var wg2 = sync.WaitGroup{}

func pushNum2() {

	for i := 0; i < 5; i++ {
		ch <- i
	}
	wg2.Done()
}

func mutiRoutine() {
	wg2.Add(2)
	go pushNum2()
	go pushNum2()
	wg2.Wait()
	close(ch)
	for {
		res, ok := <-ch
		if !ok {
			break

		}
		fmt.Println(res)
	}
}

//读写channel

func readWrite() {
	var ch chan int = make(chan int, 2)
	// 可读chan
	var readCh <-chan int = ch
	// 可写chan
	var writeCh chan<- int = ch

	writeCh <- 1
	writeCh <- 2

	fmt.Println(<-readCh)
	fmt.Println(<-readCh)

}

//

func PrimeNum(n int, c chan int) {
	for i := 2; i < n; i++ {
		if n%i == 0 {
			return
		}

	}
	c <- n
}
func selectCase() {
	c := make(chan int)
	for i := 2; i < 100001; i++ {
		go PrimeNum(i, c)
	}
Print:
	for {
		select {
		case v := <-c:
			fmt.Printf("%v\t", v)
		default:
			fmt.Printf("所有素数都已被找到")
			break Print
		}
	}

}
